/**
 * userController.js
 * 用户相关功能的控制器
 * 包含用户注册、登录、信息获取等功能
 */

const db = require('../db');
// const bcrypt = require('bcrypt'); // 需要安装: npm install bcrypt

// 暂时不使用密码加密，以便兼容现有系统，之后可以考虑逐步升级
// const SALT_ROUNDS = 10;

/**
 * 用户注册
 * @param {string} username - 用户名，至少3个字符
 * @param {string} password - 密码，至少6个字符
 * @param {string} [level='beginner'] - 用户级别
 * @param {number} [dailyNewWordsLimit=20] - 每日新词限制
 * @param {number} [dailyReviewLimit=50] - 每日复习限制
 * @returns {Promise<Object>} 包含注册结果的对象
 */
async function register(username, password, level = 'beginner', dailyNewWordsLimit = 20, dailyReviewLimit = 50) {
  // 参数验证
  if (!username || !password) {
    throw new Error('用户名和密码不能为空');
  }
  
  if (username.length < 3 || password.length < 6) {
    throw new Error('用户名至少3个字符，密码至少6个字符');
  }

  // 检查用户名是否存在
  const [existingUser] = await db.execute(
    'SELECT * FROM user WHERE username = ?',
    [username]
  );

  if (existingUser.length > 0) {
    return { success: false, message: '用户名已存在' };
  }

  try {
    // 暂时不加密密码，使用明文保存
    // const hashedPassword = await bcrypt.hash(password, SALT_ROUNDS);
    const hashedPassword = password;
    
    // 获取当前时间作为注册时间
    const now = new Date();
    
    // 执行数据库插入操作，包含新增用户字段
    const [result] = await db.execute(
      `INSERT INTO user (
        username, 
        password, 
        first_login_date, 
        correct_queries, 
        daily_new_words_limit, 
        daily_review_limit, 
        current_level, 
        total_study_time, 
        streak_days
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
      [
        username, 
        hashedPassword, 
        now, 
        0, 
        dailyNewWordsLimit, 
        dailyReviewLimit, 
        level, 
        0, 
        1  // 注册当天计为第一天
      ]
    );

    // 检查是否插入成功
    if (result.affectedRows === 0) {
      throw new Error('注册失败');
    }
    
    // 获取新插入用户的ID
    const userId = result.insertId;
    
    // 记录用户首次注册的学习记录
    await db.execute(
      `INSERT INTO daily_study_records (
        user_id, 
        study_date, 
        new_words_count, 
        review_words_count
      ) VALUES (?, ?, ?, ?)`,
      [userId, new Date(), 0, 0]
    );
    
    return { 
      success: true, 
      message: '注册成功', 
      userId 
    };
  } catch (error) {
    console.error('注册失败:', error);
    throw new Error('注册过程中发生错误: ' + error.message);
  }
}

/**
 * 用户登录
 * @param {string} username - 用户名
 * @param {string} password - 密码
 * @returns {Promise<Object|null>} 登录成功返回用户信息，失败返回null
 */
async function login(username, password) {
  try {
    // 获取用户信息
    const [rows] = await db.execute(
      `SELECT 
        id, 
        username, 
        password, 
        first_login_date, 
        correct_queries, 
        daily_new_words_limit, 
        daily_review_limit, 
        current_level, 
        total_study_time, 
        streak_days
      FROM user 
      WHERE username = ?`,
      [username]
    );

    if (rows.length === 0) {
      console.log('用户不存在');
      return null;
    }

    const user = rows[0];
    
    // 暂时直接比较密码，不使用bcrypt
    // const isPasswordValid = await bcrypt.compare(password, user.password);
    const isPasswordValid = (password === user.password);
    
    if (!isPasswordValid) {
      console.log('密码不正确');
      return null;
    }

    // 检查用户连续学习天数
    await updateUserStreak(user.id);
    
    // 不返回密码给前端
    delete user.password;
    
    return user;
  } catch (error) {
    console.error('登录失败:', error);
    throw new Error('登录过程中发生错误: ' + error.message);
  }
}

/**
 * 获取用户详细信息
 * @param {string} username - 用户名
 * @returns {Promise<Object|null>} 用户信息对象或null
 */
async function getUserInfo(username) {
  try {
    const [rows] = await db.execute(
      `SELECT 
        id, 
        username, 
        first_login_date, 
        correct_queries, 
        daily_new_words_limit, 
        daily_review_limit, 
        current_level, 
        total_study_time, 
        streak_days
      FROM user 
      WHERE username = ?`,
      [username]
    );

    if (rows.length === 0) {
      return null;
    }

    return rows[0];
  } catch (error) {
    console.error('获取用户信息失败:', error);
    throw new Error('获取用户信息过程中发生错误: ' + error.message);
  }
}

/**
 * 更新用户学习连续天数
 * @param {number} userId - 用户ID
 * @returns {Promise<void>}
 */
async function updateUserStreak(userId) {
  try {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    
    // 获取用户上次学习日期
    const [userRows] = await db.execute(
      `SELECT streak_days FROM user WHERE id = ?`,
      [userId]
    );

    if (userRows.length === 0) {
      return;
    }

    // 获取用户最后一条学习记录
    const [recordRows] = await db.execute(
      `SELECT study_date FROM daily_study_records 
       WHERE user_id = ? 
       ORDER BY study_date DESC 
       LIMIT 1`,
      [userId]
    );

    let streakDays = userRows[0].streak_days || 0;
    
    if (recordRows.length > 0) {
      const lastStudyDate = new Date(recordRows[0].study_date);
      lastStudyDate.setHours(0, 0, 0, 0);
      
      const dayDifference = Math.floor((today - lastStudyDate) / (1000 * 60 * 60 * 24));
      
      if (dayDifference === 0) {
        // 今天已经学习过，不做更改
      } else if (dayDifference === 1) {
        // 昨天学习过，连续天数+1
        streakDays += 1;
      } else {
        // 超过1天没学习，重置连续天数为1
        streakDays = 1;
      }
    }
    
    // 更新用户连续学习天数
    await db.execute(
      `UPDATE user SET streak_days = ? WHERE id = ?`,
      [streakDays, userId]
    );
    
    // 检查今天是否有学习记录，没有则创建
    const todayStr = today.toISOString().split('T')[0];
    
    const [todayRecords] = await db.execute(
      `SELECT id FROM daily_study_records 
       WHERE user_id = ? AND DATE(study_date) = ?`,
      [userId, todayStr]
    );
    
    if (todayRecords.length === 0) {
      // 创建今天的学习记录
      await db.execute(
        `INSERT INTO daily_study_records (
          user_id, 
          study_date, 
          new_words_count, 
          review_words_count
        ) VALUES (?, ?, ?, ?)`,
        [userId, today, 0, 0]
      );
    }
  } catch (error) {
    console.error('更新用户连续学习天数失败:', error);
  }
}

/**
 * 更新用户设置
 * @param {number} userId - 用户ID
 * @param {Object} settings - 要更新的设置
 * @param {string} [settings.current_level] - 用户当前级别
 * @param {number} [settings.daily_new_words_limit] - 每日新词限制
 * @param {number} [settings.daily_review_limit] - 每日复习限制
 * @returns {Promise<boolean>} 更新是否成功
 */
async function updateUserSettings(userId, settings) {
  try {
    const allowedSettings = ['current_level', 'daily_new_words_limit', 'daily_review_limit'];
    const updateValues = [];
    const params = [];
    
    // 构建动态SQL更新语句
    for (const key in settings) {
      if (allowedSettings.includes(key) && settings[key] !== undefined) {
        updateValues.push(`${key} = ?`);
        params.push(settings[key]);
      }
    }
    
    if (updateValues.length === 0) {
      return false; // 没有有效的设置需要更新
    }
    
    params.push(userId); // 添加WHERE条件的参数
    
    const [result] = await db.execute(
      `UPDATE user SET ${updateValues.join(', ')} WHERE id = ?`,
      params
    );
    
    return result.affectedRows > 0;
  } catch (error) {
    console.error('更新用户设置失败:', error);
    throw new Error('更新用户设置过程中发生错误: ' + error.message);
  }
}

// 更新用户统计数据
exports.updateUserStats = async (req, res) => {
  try {
    console.log('收到用户统计数据更新请求:', req.body);
    
    // 验证请求体
    const { userId, streakDays, accuracyRate, totalCorrect, totalIncorrect, lastStudyDate } = req.body;
    
    if (!userId) {
      return res.status(400).json({
        success: false,
        message: '缺少用户ID'
      });
    }
    
    // 连接数据库
    const db = await getDb();
    
    // 验证用户是否存在
    const user = await db.get('SELECT * FROM users WHERE id = ?', [userId]);
    if (!user) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      });
    }
    
    // 日志记录
    console.log('更新用户统计数据:',
      '用户ID:', userId,
      '连续学习天数:', streakDays,
      '正确率:', accuracyRate,
      '总正确数:', totalCorrect,
      '总错误数:', totalIncorrect,
      '最后学习日期:', lastStudyDate
    );
    
    // 更新用户统计数据
    const updateFields = [];
    const updateParams = [];
    
    // 只更新提供的字段
    if (streakDays !== undefined) {
      updateFields.push('streak_days = ?');
      updateParams.push(streakDays);
    }
    
    if (accuracyRate !== undefined) {
      updateFields.push('accuracy_rate = ?');
      updateParams.push(accuracyRate);
    }
    
    if (totalCorrect !== undefined) {
      updateFields.push('total_correct = ?');
      updateParams.push(totalCorrect);
    }
    
    if (totalIncorrect !== undefined) {
      updateFields.push('total_incorrect = ?');
      updateParams.push(totalIncorrect);
    }
    
    if (lastStudyDate !== undefined) {
      updateFields.push('last_study_date = ?');
      updateParams.push(lastStudyDate);
    }
    
    // 如果没有要更新的字段
    if (updateFields.length === 0) {
      return res.status(400).json({
        success: false,
        message: '没有提供要更新的统计数据'
      });
    }
    
    // 构建更新语句
    const updateQuery = `UPDATE users SET ${updateFields.join(', ')} WHERE id = ?`;
    updateParams.push(userId);
    
    // 执行更新
    await db.run(updateQuery, updateParams);
    
    // 记录学习统计日志（可选）
    if (lastStudyDate) {
      try {
        await db.run(
          'INSERT INTO user_study_logs (user_id, study_date, correct_count, incorrect_count) VALUES (?, ?, ?, ?)',
          [userId, lastStudyDate, totalCorrect || 0, totalIncorrect || 0]
        );
        console.log('已记录用户学习日志');
      } catch (logError) {
        console.error('记录用户学习日志失败:', logError);
        // 不影响主要流程，继续执行
      }
    }
    
    return res.json({
      success: true,
      message: '用户统计数据已更新'
    });
  } catch (error) {
    console.error('更新用户统计数据失败:', error);
    return res.status(500).json({
      success: false,
      message: '更新用户统计数据失败'
    });
  }
};

module.exports = {
  register,
  login,
  getUserInfo,
  updateUserStreak,
  updateUserSettings
}; 